Add integration coverage for the allow_circular self-rebalance path:

- test_getroutes_circular: a focused test over a synthetic gossip store
  with one deterministic cycle (us -> 1 -> 2 -> us).  Asserts that
  source == destination without allow_circular is rejected, and that with
  allow_circular the returned route keeps its trailing synthetic closing
  hop (node_id_out == the fake us_in sentinel, scid == the first mirror
  0x0x0, amount_out_msat == delivered).  Also covers mirror-scid collision
  handling: a layer-created channel squatting on 0x0x0 plus the store's own
  real block-0 channel (gossmap-compress assigns block = index + node1)
  force the allocator to skip to 0x2x0.

- test_real_data_circular: the canonical clboss-xmovefunds shape over a
  real mainnet gossmap snapshot.  Mask the source node down to a single
  drain (source-out) channel and a single distinct fill (dest-in) channel,
  then self-rebalance.  The mask makes the route deterministic at the
  endpoints: every part must leave via the drain channel and return via the
  mirrored fill channel into us_in.

Real hops in the synthetic test are pinned by node id rather than
short_channel_id_dir, since the scids the test gossip store assigns are a
harness-internal detail.

Changelog-None

…call site

Per review: instead of inject_circular_fake() silently no-oping for
normal requests, test source == destination at the do_getroutes call
site, log each stage (requested / failed / prepared), and only call
the function for circular requests.

This turns out to be a net simplification: the info->circular flag
was only ever read for the post-hoc success log, so the explicit
call-site condition lets us delete the struct field, its comment
block, its initialization, and the function's early-return guard.
The function's contract (only called for source == destination) is
now visible in the caller.

Changelog-None

Previously each circular route ended in a sentinel final hop: a fake
mirror scid and a placeholder node id the caller had to recognise and
replace with a real return channel and their own node id.  That
contract had a hole when more than one (peer -> source) channel from
the same final peer is left enabled -- e.g. parallel channels, or
letting the solver split the fill across several: the mirror-to-real
mapping exists only inside askrene, and parallel channels' properties
typically tie, so the caller cannot reconstruct which real channel
each route's solve targeted.  Non-strict forwarding usually still
delivers the funds, but the rebalance loses exactly what it is for:
which channel gets filled, the per-channel split the solver planned,
and scid-keyed bookkeeping (reservations, failure feedback) on the
final hop.

Record the mapping at inject time (struct circular_unsplit: one entry
per mirror, fake scid -> real scidd, plus the real source id) and
apply it in the solver child when serializing routes: any hop over a
mirror's fake scid -- only final hops can match, by construction --
is rewritten to the real (peer -> source) return channel with
node_id_out set to source.  The table is built in the parent before
the fork, so the child inherits it.

Returned circular routes are now directly usable for building the
payment; no placeholder substitution is required, and the sentinel
never appears in output.  The new multi-inbound test covers the
previously unanswerable case: an amount that must split across two
inbound channels from the same final peer, with each route's final
hop carrying the correct distinct real scid.

Changelog-None

… routes

The auto.allow_circular layer grants permission (source may equal
destination); it does not change behavior.  On a normal request, where
source and destination differ, the layer must be a no-op.  This is
structural: the circular setup runs only behind the source ==
destination check at the do_getroutes call site.

Say so in the schema documentation, and pin it with an equivalence
test: getroutes returns the identical result with and without the
layer on a non-circular request.

Changelog-None